
// 节流
function throttle(fn, interval = 300) {
  var enterTime = 0// 触发的时间
  var gapTime = interval || 300 // 间隔时间，如果interval不传，则默认300ms
  return function() {
    var context = this
    var backTime = new Date()// 第一次函数return即触发的时间
    if (backTime - enterTime > gapTime) {
      fn.call(context, arguments[0])
      enterTime = backTime// 赋值给第一次触发的时间，这样就保存了第二次触发的时间
    }
  }
}
// 防抖
function debounce(fn, interval = 1000, isImmediate = false) {
  var timer = null
  return function() {
    if (timer) {
      clearTimeout(timer)
    }
    var context = this
    var args = arguments[0]// 保存此处的arguments，因为setTimeout是全局的，arguments不是防抖函数需要的。
    if (isImmediate) {
      fn.call(context, args)
      isImmediate = false
      timer = setTimeout(function() {
        isImmediate = true
      }, interval)
    }
  }
}

module.exports = {
  debounce: debounce, // 防抖
  throttle: throttle// 节流

}
// export function debounce(fn, delay) {
//   var delay = delay || 500
//   var timer
//   return function() {
//     console.log('调用了debounce方法')
//     const args = arguments
//     if (timer) {
//       clearTimeout(timer)
//     }
//     timer = setTimeout(() => {
//       timer = null
//       fn.apply(this, args)
//     }, delay)
//   }
// }

// /**
//    * @desc 函数节流
//    * @param fn 函数
//    * @param interval 函数执行间隔时间毫秒数 默认1s
//   */
// export function throttle(fn, interval) {
//   var last
//   var timer
//   var interval = interval || 1000
//   return function() {
//     console.log('调用了throttle方法')
//     var th = this
//     var args = arguments
//     var now = +new Date()
//     if (last && now - last < interval) {
//       clearTimeout(timer)
//       timer = setTimeout(function() {
//         last = now
//         fn.apply(th, args)
//       }, interval)
//     } else {
//       last = now
//       fn.apply(th, args)
//     }
//   }
// }
